

import java.sql.Connection;
import java.util.*;

class Student {
    public String id;

    public Student(String id) {
        this.id = id;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(id, student.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}
public class Text {

    public List<String> topKFrequent(String[] words, int k) {
        //1. 统计每个单词出现的次数
        Map<String,Integer> map = new HashMap<>();
        for(String word:words) {
            if(map.get(word) == null) {
                // 如果map 里面没有就 添加
                map.put(word,1);
            }else {
                // map 里面存储过 就取出 val 加一再存储进去
                int val = map.get(word);
                map.put(word,val+1);
            }
        }


        //2. 创建小根堆,指定比较的方式
        PriorityQueue<Map.Entry<String,Integer>> minHeap =
                new PriorityQueue<>(new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {

                if(o1.getValue().compareTo(o2.getValue()) == 0) {
                    return o2.getKey().compareTo(o1.getKey());
                }
                return o1.getValue() - o2.getValue();
            }
        });
        // 3.遍历 map 将出现频率前k个单词放置到小根堆当中
        for(Map.Entry<String,Integer> entry:map.entrySet()) {
            if(minHeap.size() < k) {
                //如果 小根堆里面的数量 小于 k 就直接往里面放就可以了
                minHeap.offer(entry);
            }else {
                Map.Entry<String,Integer> top = minHeap.peek();

                if (top.getValue().compareTo(entry.getValue()) == 0) {
                    if(top.getValue().compareTo(entry.getValue()) > 0) {
                        // 判断要放的 val 是不是比对顶元素大 如果比对顶元素大就直接放进去
                        minHeap.poll();
                        minHeap.offer(entry);
                    }
                }else {
                    // 如果根对顶元素一样大，就根据 单词字典排序来存储
                    if(top.getValue().compareTo(entry.getValue()) < 0) {
                        minHeap.poll();
                        minHeap.offer(entry);
                    }
                }
            }
        }
        // 将小根堆的值拿出来 放入到链表中
        List<String> list = new ArrayList<>();
        for(int i = 0; i < k;i++) {
            list.add(minHeap.poll().getKey());
        }
        //逆置链表
        Collections.reverse(list);
        return list;
    }
    public static void main(String[] args) {

    }

    public Node copyRandomList(Node head) {
        Node cur = head;
        HashMap<Node,Node> map = new HashMap<>();
        while(cur != null) {
            Node node = new Node(cur.val);
            map.put(cur,node);
            cur = cur.next;
        }
        //当前的key vla 都已经放入到了 map 当中
        cur = head; //让cur 回到头部再次遍历
        while(cur != null) {
            map.get(cur).next = map.get(cur.next);// 关联next
            map.get(cur).random = map.get(cur.random);
            cur = cur.next;
        }
        // 已经全部关联关系
        // 接下来返回 head
        return map.get(head);
    }
    public static void main4(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        String str1 = null;
        String str2 = null;
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            str1 = in.nextLine();
            str2 = in.nextLine();
        }
        func(str1,str2);
    }
    public static void func(String str1,String str2) {
        HashSet<Character> set1 = new HashSet<>();
        for(char ch: str2.toUpperCase().toCharArray()) { // 先大写，再转换成字符数组
            set1.add(ch);
        }
        HashSet<Character> set2 = new HashSet<>();
        for(char ch: str1.toUpperCase().toCharArray()) {
            if(!set1.contains(ch) && !set2.contains(ch)) { //先判断是不是坏件 然后再将坏件放入set2中 保证坏件只输出一次
                System.out.print(ch);
                set2.add(ch);
            }
        }
    }

    public static void main3(String[] args) {
        Student student1 = new Student("620123456");
        Student student2 = new Student("620123456");
        HashMap<Student,Integer> map = new HashMap<>();
        System.out.println(student1.hashCode());
        System.out.println(student2.hashCode());
        map.put(student1,2);
        System.out.println(map.get(student2));
        HashBucket<Student,Integer> hashBucket = new HashBucket<>();
        hashBucket.put(student1,10);
        System.out.println(hashBucket.getValue(student2));
    }

    public static void main2(String[] args) {
        //set 的方法的实现
        TreeSet<Integer> set = new TreeSet<>();
        set.add(1);
        set.add(12);
        set.add(23);
        set.add(34);
        System.out.println(set);
        System.out.println(set.contains(1));   //判断是否在集合中
        set.iterator();//返回迭代器
        System.out.println(set.remove(1)); //删除集合中的
        System.out.println(set.size()); //返回set中元素的个数
        System.out.println(set.isEmpty()); //检测set是否为空，空返回true，否则返回false
        Object[] array = set.toArray(); //将set中的元素转换为数组返回
        for(Object n :array) {
            System.out.print(n + " ");
        }
        System.out.println();
        TreeSet<Integer> set1 = new TreeSet<>();
        set1.add(12);
        set1.add(23);
        System.out.println(set.containsAll(set1)); //集合c中的元素是否在set中全部存在，是返回true，否则返回 false
        TreeSet<Integer> set2 = new TreeSet<>();
        set2.add(88);
        set2.add(99);
        set.addAll(set2); //将集合c中的元素添加到set中，可以达到去重的效果

        System.out.println(set);



    }
    public static void main1(String[] args) {
        //map 方法的实现
        Map<String,Integer> map = new TreeMap<>();
        map.put("语文",8);
        map.put("数学",7);
        map.put("英文",9);
        map.put("语文",9);
        System.out.println(map);
        System.out.println(map.get("语文"));//返回value值
        System.out.println(map.getOrDefault("历史", 999));
        map.remove("英文");
        System.out.println(map);
        System.out.println(map.keySet());
        System.out.println(map.values());
        System.out.println(map.entrySet());//返回所有键值对关系
        System.out.println(map.containsKey("语文"));
        System.out.println(map.containsValue(9));

    }
}
